home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / collections / ArrayList.as < prev    next >
Encoding:
Text File  |  2008-10-29  |  10.3 KB  |  332 lines
  1. package mx.collections
  2. {
  3.    import flash.events.EventDispatcher;
  4.    import flash.events.IEventDispatcher;
  5.    import flash.utils.IDataInput;
  6.    import flash.utils.IDataOutput;
  7.    import flash.utils.IExternalizable;
  8.    import flash.utils.getQualifiedClassName;
  9.    import mx.core.IPropertyChangeNotifier;
  10.    import mx.core.mx_internal;
  11.    import mx.events.CollectionEvent;
  12.    import mx.events.CollectionEventKind;
  13.    import mx.events.PropertyChangeEvent;
  14.    import mx.events.PropertyChangeEventKind;
  15.    import mx.resources.IResourceManager;
  16.    import mx.resources.ResourceManager;
  17.    import mx.utils.ArrayUtil;
  18.    import mx.utils.UIDUtil;
  19.    
  20.    use namespace mx_internal;
  21.    
  22.    public class ArrayList extends EventDispatcher implements IList, IExternalizable, IPropertyChangeNotifier
  23.    {
  24.       mx_internal static const VERSION:String = "3.0.0.0";
  25.       
  26.       private var _source:Array;
  27.       
  28.       private var _dispatchEvents:int = 0;
  29.       
  30.       private var _uid:String;
  31.       
  32.       private var resourceManager:IResourceManager;
  33.       
  34.       public function ArrayList(param1:Array = null)
  35.       {
  36.          resourceManager = ResourceManager.getInstance();
  37.          super();
  38.          disableEvents();
  39.          this.source = param1;
  40.          enableEvents();
  41.          _uid = UIDUtil.createUID();
  42.       }
  43.       
  44.       public function itemUpdated(param1:Object, param2:Object = null, param3:Object = null, param4:Object = null) : void
  45.       {
  46.          var _loc5_:PropertyChangeEvent = new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE);
  47.          _loc5_.kind = PropertyChangeEventKind.UPDATE;
  48.          _loc5_.source = param1;
  49.          _loc5_.property = param2;
  50.          _loc5_.oldValue = param3;
  51.          _loc5_.newValue = param4;
  52.          itemUpdateHandler(_loc5_);
  53.       }
  54.       
  55.       public function readExternal(param1:IDataInput) : void
  56.       {
  57.          source = param1.readObject();
  58.       }
  59.       
  60.       private function internalDispatchEvent(param1:String, param2:Object = null, param3:int = -1) : void
  61.       {
  62.          var _loc4_:CollectionEvent = null;
  63.          var _loc5_:PropertyChangeEvent = null;
  64.          if(_dispatchEvents == 0)
  65.          {
  66.             if(hasEventListener(CollectionEvent.COLLECTION_CHANGE))
  67.             {
  68.                _loc4_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  69.                _loc4_.kind = param1;
  70.                _loc4_.items.push(param2);
  71.                _loc4_.location = param3;
  72.                dispatchEvent(_loc4_);
  73.             }
  74.             if(hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE) && (param1 == CollectionEventKind.ADD || param1 == CollectionEventKind.REMOVE))
  75.             {
  76.                _loc5_ = new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE);
  77.                _loc5_.property = param3;
  78.                if(param1 == CollectionEventKind.ADD)
  79.                {
  80.                   _loc5_.newValue = param2;
  81.                }
  82.                else
  83.                {
  84.                   _loc5_.oldValue = param2;
  85.                }
  86.                dispatchEvent(_loc5_);
  87.             }
  88.          }
  89.       }
  90.       
  91.       public function removeAll() : void
  92.       {
  93.          var _loc1_:int = 0;
  94.          var _loc2_:int = 0;
  95.          if(length > 0)
  96.          {
  97.             _loc1_ = length;
  98.             _loc2_ = 0;
  99.             while(_loc2_ < _loc1_)
  100.             {
  101.                stopTrackUpdates(source[_loc2_]);
  102.                _loc2_++;
  103.             }
  104.             source.splice(0,length);
  105.             internalDispatchEvent(CollectionEventKind.RESET);
  106.          }
  107.       }
  108.       
  109.       public function removeItemAt(param1:int) : Object
  110.       {
  111.          var _loc3_:String = null;
  112.          if(param1 < 0 || param1 >= length)
  113.          {
  114.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  115.             throw new RangeError(_loc3_);
  116.          }
  117.          var _loc2_:Object = source.splice(param1,1)[0];
  118.          stopTrackUpdates(_loc2_);
  119.          internalDispatchEvent(CollectionEventKind.REMOVE,_loc2_,param1);
  120.          return _loc2_;
  121.       }
  122.       
  123.       public function get uid() : String
  124.       {
  125.          return _uid;
  126.       }
  127.       
  128.       public function getItemIndex(param1:Object) : int
  129.       {
  130.          return ArrayUtil.getItemIndex(param1,source);
  131.       }
  132.       
  133.       public function writeExternal(param1:IDataOutput) : void
  134.       {
  135.          param1.writeObject(_source);
  136.       }
  137.       
  138.       public function addItem(param1:Object) : void
  139.       {
  140.          addItemAt(param1,length);
  141.       }
  142.       
  143.       public function toArray() : Array
  144.       {
  145.          return source.concat();
  146.       }
  147.       
  148.       private function disableEvents() : void
  149.       {
  150.          --_dispatchEvents;
  151.       }
  152.       
  153.       public function get source() : Array
  154.       {
  155.          return _source;
  156.       }
  157.       
  158.       public function getItemAt(param1:int, param2:int = 0) : Object
  159.       {
  160.          var _loc3_:String = null;
  161.          if(param1 < 0 || param1 >= length)
  162.          {
  163.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  164.             throw new RangeError(_loc3_);
  165.          }
  166.          return source[param1];
  167.       }
  168.       
  169.       public function set uid(param1:String) : void
  170.       {
  171.          _uid = param1;
  172.       }
  173.       
  174.       public function setItemAt(param1:Object, param2:int) : Object
  175.       {
  176.          var _loc4_:String = null;
  177.          var _loc5_:Boolean = false;
  178.          var _loc6_:Boolean = false;
  179.          var _loc7_:PropertyChangeEvent = null;
  180.          var _loc8_:CollectionEvent = null;
  181.          if(param2 < 0 || param2 >= length)
  182.          {
  183.             _loc4_ = resourceManager.getString("collections","outOfBounds",[param2]);
  184.             throw new RangeError(_loc4_);
  185.          }
  186.          var _loc3_:Object = source[param2];
  187.          source[param2] = param1;
  188.          stopTrackUpdates(_loc3_);
  189.          startTrackUpdates(param1);
  190.          if(_dispatchEvents == 0)
  191.          {
  192.             _loc5_ = hasEventListener(CollectionEvent.COLLECTION_CHANGE);
  193.             _loc6_ = hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE);
  194.             if(_loc5_ || _loc6_)
  195.             {
  196.                _loc7_ = new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE);
  197.                _loc7_.kind = PropertyChangeEventKind.UPDATE;
  198.                _loc7_.oldValue = _loc3_;
  199.                _loc7_.newValue = param1;
  200.                _loc7_.property = param2;
  201.             }
  202.             if(_loc5_)
  203.             {
  204.                _loc8_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  205.                _loc8_.kind = CollectionEventKind.REPLACE;
  206.                _loc8_.location = param2;
  207.                _loc8_.items.push(_loc7_);
  208.                dispatchEvent(_loc8_);
  209.             }
  210.             if(_loc6_)
  211.             {
  212.                dispatchEvent(_loc7_);
  213.             }
  214.          }
  215.          return _loc3_;
  216.       }
  217.       
  218.       public function get length() : int
  219.       {
  220.          if(source)
  221.          {
  222.             return source.length;
  223.          }
  224.          return 0;
  225.       }
  226.       
  227.       protected function stopTrackUpdates(param1:Object) : void
  228.       {
  229.          if(Boolean(param1) && param1 is IEventDispatcher)
  230.          {
  231.             IEventDispatcher(param1).removeEventListener(PropertyChangeEvent.PROPERTY_CHANGE,itemUpdateHandler);
  232.          }
  233.       }
  234.       
  235.       protected function itemUpdateHandler(param1:PropertyChangeEvent) : void
  236.       {
  237.          var _loc2_:PropertyChangeEvent = null;
  238.          var _loc3_:uint = 0;
  239.          internalDispatchEvent(CollectionEventKind.UPDATE,param1);
  240.          if(_dispatchEvents == 0 && hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE))
  241.          {
  242.             _loc2_ = PropertyChangeEvent(param1.clone());
  243.             _loc3_ = uint(getItemIndex(param1.target));
  244.             _loc2_.property = _loc3_.toString() + "." + param1.property;
  245.             dispatchEvent(_loc2_);
  246.          }
  247.       }
  248.       
  249.       public function addItemAt(param1:Object, param2:int) : void
  250.       {
  251.          var _loc3_:String = null;
  252.          if(param2 < 0 || param2 > length)
  253.          {
  254.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param2]);
  255.             throw new RangeError(_loc3_);
  256.          }
  257.          source.splice(param2,0,param1);
  258.          startTrackUpdates(param1);
  259.          internalDispatchEvent(CollectionEventKind.ADD,param1,param2);
  260.       }
  261.       
  262.       public function removeItem(param1:Object) : Boolean
  263.       {
  264.          var _loc2_:int = getItemIndex(param1);
  265.          var _loc3_:* = _loc2_ >= 0;
  266.          if(_loc3_)
  267.          {
  268.             removeItemAt(_loc2_);
  269.          }
  270.          return _loc3_;
  271.       }
  272.       
  273.       protected function startTrackUpdates(param1:Object) : void
  274.       {
  275.          if(Boolean(param1) && param1 is IEventDispatcher)
  276.          {
  277.             IEventDispatcher(param1).addEventListener(PropertyChangeEvent.PROPERTY_CHANGE,itemUpdateHandler,false,0,true);
  278.          }
  279.       }
  280.       
  281.       override public function toString() : String
  282.       {
  283.          if(source)
  284.          {
  285.             return source.toString();
  286.          }
  287.          return getQualifiedClassName(this);
  288.       }
  289.       
  290.       private function enableEvents() : void
  291.       {
  292.          ++_dispatchEvents;
  293.          if(_dispatchEvents > 0)
  294.          {
  295.             _dispatchEvents = 0;
  296.          }
  297.       }
  298.       
  299.       public function set source(param1:Array) : void
  300.       {
  301.          var _loc2_:int = 0;
  302.          var _loc3_:int = 0;
  303.          var _loc4_:CollectionEvent = null;
  304.          if(Boolean(_source) && Boolean(_source.length))
  305.          {
  306.             _loc3_ = int(_source.length);
  307.             _loc2_ = 0;
  308.             while(_loc2_ < _loc3_)
  309.             {
  310.                stopTrackUpdates(_source[_loc2_]);
  311.                _loc2_++;
  312.             }
  313.          }
  314.          _source = !!param1 ? param1 : [];
  315.          _loc3_ = int(_source.length);
  316.          _loc2_ = 0;
  317.          while(_loc2_ < _loc3_)
  318.          {
  319.             startTrackUpdates(_source[_loc2_]);
  320.             _loc2_++;
  321.          }
  322.          if(_dispatchEvents == 0)
  323.          {
  324.             _loc4_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  325.             _loc4_.kind = CollectionEventKind.RESET;
  326.             dispatchEvent(_loc4_);
  327.          }
  328.       }
  329.    }
  330. }
  331.  
  332.